//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Inspector2 service.
///
/// Amazon Inspector is a vulnerability discovery service that automates continuous scanning for security vulnerabilities within your Amazon EC2, Amazon ECR, and Amazon Web Services Lambda environments.
public struct Inspector2: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Inspector2 client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Inspector2",
            serviceIdentifier: "inspector2",
            serviceProtocol: .restjson,
            apiVersion: "2020-06-08",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: Inspector2ErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "inspector2-fips.us-east-1.amazonaws.com",
            "us-east-2": "inspector2-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "inspector2-fips.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "inspector2-fips.us-gov-west-1.amazonaws.com",
            "us-west-1": "inspector2-fips.us-west-1.amazonaws.com",
            "us-west-2": "inspector2-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Associates an Amazon Web Services account with an Amazon Inspector delegated administrator. An HTTP 200 response indicates the association was successfully started, but doesn’t indicate whether it was completed. You can check if the association completed by using ListMembers for multiple accounts or GetMembers for a single account.
    @Sendable
    @inlinable
    public func associateMember(_ input: AssociateMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateMemberResponse {
        try await self.client.execute(
            operation: "AssociateMember", 
            path: "/members/associate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an Amazon Web Services account with an Amazon Inspector delegated administrator. An HTTP 200 response indicates the association was successfully started, but doesn’t indicate whether it was completed. You can check if the association completed by using ListMembers for multiple accounts or GetMembers for a single account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account ID of the member account to be associated.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateMember(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateMemberResponse {
        let input = AssociateMemberRequest(
            accountId: accountId
        )
        return try await self.associateMember(input, logger: logger)
    }

    /// Associates multiple code repositories with an Amazon Inspector code security scan configuration.
    @Sendable
    @inlinable
    public func batchAssociateCodeSecurityScanConfiguration(_ input: BatchAssociateCodeSecurityScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchAssociateCodeSecurityScanConfigurationResponse {
        try await self.client.execute(
            operation: "BatchAssociateCodeSecurityScanConfiguration", 
            path: "/codesecurity/scan-configuration/batch/associate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates multiple code repositories with an Amazon Inspector code security scan configuration.
    ///
    /// Parameters:
    ///   - associateConfigurationRequests: A list of code repositories to associate with the specified scan configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchAssociateCodeSecurityScanConfiguration(
        associateConfigurationRequests: [AssociateConfigurationRequest],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchAssociateCodeSecurityScanConfigurationResponse {
        let input = BatchAssociateCodeSecurityScanConfigurationRequest(
            associateConfigurationRequests: associateConfigurationRequests
        )
        return try await self.batchAssociateCodeSecurityScanConfiguration(input, logger: logger)
    }

    /// Disassociates multiple code repositories from an Amazon Inspector code security scan configuration.
    @Sendable
    @inlinable
    public func batchDisassociateCodeSecurityScanConfiguration(_ input: BatchDisassociateCodeSecurityScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDisassociateCodeSecurityScanConfigurationResponse {
        try await self.client.execute(
            operation: "BatchDisassociateCodeSecurityScanConfiguration", 
            path: "/codesecurity/scan-configuration/batch/disassociate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates multiple code repositories from an Amazon Inspector code security scan configuration.
    ///
    /// Parameters:
    ///   - disassociateConfigurationRequests: A list of code repositories to disassociate from the specified scan configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDisassociateCodeSecurityScanConfiguration(
        disassociateConfigurationRequests: [DisassociateConfigurationRequest],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDisassociateCodeSecurityScanConfigurationResponse {
        let input = BatchDisassociateCodeSecurityScanConfigurationRequest(
            disassociateConfigurationRequests: disassociateConfigurationRequests
        )
        return try await self.batchDisassociateCodeSecurityScanConfiguration(input, logger: logger)
    }

    /// Retrieves the Amazon Inspector status of multiple Amazon Web Services accounts within your environment.
    @Sendable
    @inlinable
    public func batchGetAccountStatus(_ input: BatchGetAccountStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetAccountStatusResponse {
        try await self.client.execute(
            operation: "BatchGetAccountStatus", 
            path: "/status/batch/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the Amazon Inspector status of multiple Amazon Web Services accounts within your environment.
    ///
    /// Parameters:
    ///   - accountIds: The 12-digit Amazon Web Services account IDs of the accounts to retrieve Amazon Inspector status for.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetAccountStatus(
        accountIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetAccountStatusResponse {
        let input = BatchGetAccountStatusRequest(
            accountIds: accountIds
        )
        return try await self.batchGetAccountStatus(input, logger: logger)
    }

    /// Retrieves code snippets from findings that Amazon Inspector detected code vulnerabilities in.
    @Sendable
    @inlinable
    public func batchGetCodeSnippet(_ input: BatchGetCodeSnippetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetCodeSnippetResponse {
        try await self.client.execute(
            operation: "BatchGetCodeSnippet", 
            path: "/codesnippet/batchget", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves code snippets from findings that Amazon Inspector detected code vulnerabilities in.
    ///
    /// Parameters:
    ///   - findingArns: An array of finding ARNs for the findings you want to retrieve code snippets from.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetCodeSnippet(
        findingArns: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetCodeSnippetResponse {
        let input = BatchGetCodeSnippetRequest(
            findingArns: findingArns
        )
        return try await self.batchGetCodeSnippet(input, logger: logger)
    }

    /// Gets vulnerability details for findings.
    @Sendable
    @inlinable
    public func batchGetFindingDetails(_ input: BatchGetFindingDetailsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetFindingDetailsResponse {
        try await self.client.execute(
            operation: "BatchGetFindingDetails", 
            path: "/findings/details/batch/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets vulnerability details for findings.
    ///
    /// Parameters:
    ///   - findingArns: A list of finding ARNs.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetFindingDetails(
        findingArns: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetFindingDetailsResponse {
        let input = BatchGetFindingDetailsRequest(
            findingArns: findingArns
        )
        return try await self.batchGetFindingDetails(input, logger: logger)
    }

    /// Gets free trial status for multiple Amazon Web Services accounts.
    @Sendable
    @inlinable
    public func batchGetFreeTrialInfo(_ input: BatchGetFreeTrialInfoRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetFreeTrialInfoResponse {
        try await self.client.execute(
            operation: "BatchGetFreeTrialInfo", 
            path: "/freetrialinfo/batchget", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets free trial status for multiple Amazon Web Services accounts.
    ///
    /// Parameters:
    ///   - accountIds: The account IDs to get free trial status for.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetFreeTrialInfo(
        accountIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetFreeTrialInfoResponse {
        let input = BatchGetFreeTrialInfoRequest(
            accountIds: accountIds
        )
        return try await self.batchGetFreeTrialInfo(input, logger: logger)
    }

    /// Retrieves Amazon Inspector deep inspection activation status of multiple member accounts within your organization. You must be the delegated administrator of an organization in Amazon Inspector to use this API.
    @Sendable
    @inlinable
    public func batchGetMemberEc2DeepInspectionStatus(_ input: BatchGetMemberEc2DeepInspectionStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetMemberEc2DeepInspectionStatusResponse {
        try await self.client.execute(
            operation: "BatchGetMemberEc2DeepInspectionStatus", 
            path: "/ec2deepinspectionstatus/member/batch/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves Amazon Inspector deep inspection activation status of multiple member accounts within your organization. You must be the delegated administrator of an organization in Amazon Inspector to use this API.
    ///
    /// Parameters:
    ///   - accountIds: The unique identifiers for the Amazon Web Services accounts to retrieve Amazon Inspector deep inspection activation status for.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetMemberEc2DeepInspectionStatus(
        accountIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetMemberEc2DeepInspectionStatusResponse {
        let input = BatchGetMemberEc2DeepInspectionStatusRequest(
            accountIds: accountIds
        )
        return try await self.batchGetMemberEc2DeepInspectionStatus(input, logger: logger)
    }

    /// Activates or deactivates Amazon Inspector deep inspection for the provided member accounts in your organization. You must be the delegated administrator of an organization in Amazon Inspector to use this API.
    @Sendable
    @inlinable
    public func batchUpdateMemberEc2DeepInspectionStatus(_ input: BatchUpdateMemberEc2DeepInspectionStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchUpdateMemberEc2DeepInspectionStatusResponse {
        try await self.client.execute(
            operation: "BatchUpdateMemberEc2DeepInspectionStatus", 
            path: "/ec2deepinspectionstatus/member/batch/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Activates or deactivates Amazon Inspector deep inspection for the provided member accounts in your organization. You must be the delegated administrator of an organization in Amazon Inspector to use this API.
    ///
    /// Parameters:
    ///   - accountIds: The unique identifiers for the Amazon Web Services accounts to change Amazon Inspector deep inspection status for.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchUpdateMemberEc2DeepInspectionStatus(
        accountIds: [MemberAccountEc2DeepInspectionStatus],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchUpdateMemberEc2DeepInspectionStatusResponse {
        let input = BatchUpdateMemberEc2DeepInspectionStatusRequest(
            accountIds: accountIds
        )
        return try await self.batchUpdateMemberEc2DeepInspectionStatus(input, logger: logger)
    }

    /// Cancels the given findings report.
    @Sendable
    @inlinable
    public func cancelFindingsReport(_ input: CancelFindingsReportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelFindingsReportResponse {
        try await self.client.execute(
            operation: "CancelFindingsReport", 
            path: "/reporting/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels the given findings report.
    ///
    /// Parameters:
    ///   - reportId: The ID of the report to be canceled.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelFindingsReport(
        reportId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelFindingsReportResponse {
        let input = CancelFindingsReportRequest(
            reportId: reportId
        )
        return try await self.cancelFindingsReport(input, logger: logger)
    }

    /// Cancels a software bill of materials (SBOM) report.
    @Sendable
    @inlinable
    public func cancelSbomExport(_ input: CancelSbomExportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelSbomExportResponse {
        try await self.client.execute(
            operation: "CancelSbomExport", 
            path: "/sbomexport/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels a software bill of materials (SBOM) report.
    ///
    /// Parameters:
    ///   - reportId: The report ID of the SBOM export to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelSbomExport(
        reportId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelSbomExportResponse {
        let input = CancelSbomExportRequest(
            reportId: reportId
        )
        return try await self.cancelSbomExport(input, logger: logger)
    }

    /// Creates a CIS scan configuration.
    @Sendable
    @inlinable
    public func createCisScanConfiguration(_ input: CreateCisScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCisScanConfigurationResponse {
        try await self.client.execute(
            operation: "CreateCisScanConfiguration", 
            path: "/cis/scan-configuration/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a CIS scan configuration.
    ///
    /// Parameters:
    ///   - scanName: The scan name for the CIS scan configuration.
    ///   - schedule: The schedule for the CIS scan configuration.
    ///   - securityLevel:  The security level for the CIS scan configuration. Security level refers to the Benchmark levels that CIS assigns to a profile.
    ///   - tags: The tags for the CIS scan configuration.
    ///   - targets: The targets for the CIS scan configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCisScanConfiguration(
        scanName: String,
        schedule: Schedule,
        securityLevel: CisSecurityLevel,
        tags: [String: String]? = nil,
        targets: CreateCisTargets,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCisScanConfigurationResponse {
        let input = CreateCisScanConfigurationRequest(
            scanName: scanName, 
            schedule: schedule, 
            securityLevel: securityLevel, 
            tags: tags, 
            targets: targets
        )
        return try await self.createCisScanConfiguration(input, logger: logger)
    }

    /// Creates a code security integration with a source code repository provider. After calling the CreateCodeSecurityIntegration operation, you complete authentication and authorization with your provider. Next you call the UpdateCodeSecurityIntegration operation to provide the details to complete the integration setup
    @Sendable
    @inlinable
    public func createCodeSecurityIntegration(_ input: CreateCodeSecurityIntegrationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCodeSecurityIntegrationResponse {
        try await self.client.execute(
            operation: "CreateCodeSecurityIntegration", 
            path: "/codesecurity/integration/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a code security integration with a source code repository provider. After calling the CreateCodeSecurityIntegration operation, you complete authentication and authorization with your provider. Next you call the UpdateCodeSecurityIntegration operation to provide the details to complete the integration setup
    ///
    /// Parameters:
    ///   - details: The integration details specific to the repository provider type.
    ///   - name: The name of the code security integration.
    ///   - tags: The tags to apply to the code security integration.
    ///   - type: The type of repository provider for the integration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCodeSecurityIntegration(
        details: CreateIntegrationDetail? = nil,
        name: String,
        tags: [String: String]? = nil,
        type: IntegrationType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCodeSecurityIntegrationResponse {
        let input = CreateCodeSecurityIntegrationRequest(
            details: details, 
            name: name, 
            tags: tags, 
            type: type
        )
        return try await self.createCodeSecurityIntegration(input, logger: logger)
    }

    /// Creates a scan configuration for code security scanning.
    @Sendable
    @inlinable
    public func createCodeSecurityScanConfiguration(_ input: CreateCodeSecurityScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCodeSecurityScanConfigurationResponse {
        try await self.client.execute(
            operation: "CreateCodeSecurityScanConfiguration", 
            path: "/codesecurity/scan-configuration/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a scan configuration for code security scanning.
    ///
    /// Parameters:
    ///   - configuration: The configuration settings for the code security scan.
    ///   - level: The security level for the scan configuration.
    ///   - name: The name of the scan configuration.
    ///   - scopeSettings: The scope settings that define which repositories will be scanned. Include this parameter to create a default scan configuration. Otherwise Amazon Inspector creates a general scan configuration.  A default scan configuration automatically applies to all existing and future projects imported into Amazon Inspector. Use the BatchAssociateCodeSecurityScanConfiguration operation to associate a general scan configuration with projects.
    ///   - tags: The tags to apply to the scan configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCodeSecurityScanConfiguration(
        configuration: CodeSecurityScanConfiguration,
        level: ConfigurationLevel,
        name: String,
        scopeSettings: ScopeSettings? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCodeSecurityScanConfigurationResponse {
        let input = CreateCodeSecurityScanConfigurationRequest(
            configuration: configuration, 
            level: level, 
            name: name, 
            scopeSettings: scopeSettings, 
            tags: tags
        )
        return try await self.createCodeSecurityScanConfiguration(input, logger: logger)
    }

    /// Creates a filter resource using specified filter criteria. When the filter action is set to SUPPRESS this action creates a suppression rule.
    @Sendable
    @inlinable
    public func createFilter(_ input: CreateFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFilterResponse {
        try await self.client.execute(
            operation: "CreateFilter", 
            path: "/filters/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a filter resource using specified filter criteria. When the filter action is set to SUPPRESS this action creates a suppression rule.
    ///
    /// Parameters:
    ///   - action: Defines the action that is to be applied to the findings that match the filter.
    ///   - description: A description of the filter.
    ///   - filterCriteria: Defines the criteria to be used in the filter for querying findings.
    ///   - name: The name of the filter. Minimum length of 3. Maximum length of 64. Valid characters include alphanumeric characters, dot (.), underscore (_), and dash (-). Spaces are not allowed.
    ///   - reason: The reason for creating the filter.
    ///   - tags: A list of tags for the filter.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFilter(
        action: FilterAction,
        description: String? = nil,
        filterCriteria: FilterCriteria,
        name: String,
        reason: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFilterResponse {
        let input = CreateFilterRequest(
            action: action, 
            description: description, 
            filterCriteria: filterCriteria, 
            name: name, 
            reason: reason, 
            tags: tags
        )
        return try await self.createFilter(input, logger: logger)
    }

    /// Creates a finding report. By default only ACTIVE findings are returned in the report. To see SUPRESSED or CLOSED findings you must specify a value for the findingStatus filter criteria.
    @Sendable
    @inlinable
    public func createFindingsReport(_ input: CreateFindingsReportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFindingsReportResponse {
        try await self.client.execute(
            operation: "CreateFindingsReport", 
            path: "/reporting/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a finding report. By default only ACTIVE findings are returned in the report. To see SUPRESSED or CLOSED findings you must specify a value for the findingStatus filter criteria.
    ///
    /// Parameters:
    ///   - filterCriteria: The filter criteria to apply to the results of the finding report.
    ///   - reportFormat: The format to generate the report in.
    ///   - s3Destination: The Amazon S3 export destination for the report.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFindingsReport(
        filterCriteria: FilterCriteria? = nil,
        reportFormat: ReportFormat,
        s3Destination: Destination,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFindingsReportResponse {
        let input = CreateFindingsReportRequest(
            filterCriteria: filterCriteria, 
            reportFormat: reportFormat, 
            s3Destination: s3Destination
        )
        return try await self.createFindingsReport(input, logger: logger)
    }

    /// Creates a software bill of materials (SBOM) report.
    @Sendable
    @inlinable
    public func createSbomExport(_ input: CreateSbomExportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSbomExportResponse {
        try await self.client.execute(
            operation: "CreateSbomExport", 
            path: "/sbomexport/create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a software bill of materials (SBOM) report.
    ///
    /// Parameters:
    ///   - reportFormat: The output format for the software bill of materials (SBOM) report.
    ///   - resourceFilterCriteria: The resource filter criteria for the software bill of materials (SBOM) report.
    ///   - s3Destination: Contains details of the Amazon S3 bucket and KMS key used to export findings.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSbomExport(
        reportFormat: SbomReportFormat,
        resourceFilterCriteria: ResourceFilterCriteria? = nil,
        s3Destination: Destination,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSbomExportResponse {
        let input = CreateSbomExportRequest(
            reportFormat: reportFormat, 
            resourceFilterCriteria: resourceFilterCriteria, 
            s3Destination: s3Destination
        )
        return try await self.createSbomExport(input, logger: logger)
    }

    /// Deletes a CIS scan configuration.
    @Sendable
    @inlinable
    public func deleteCisScanConfiguration(_ input: DeleteCisScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCisScanConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteCisScanConfiguration", 
            path: "/cis/scan-configuration/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a CIS scan configuration.
    ///
    /// Parameters:
    ///   - scanConfigurationArn: The ARN of the CIS scan configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCisScanConfiguration(
        scanConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCisScanConfigurationResponse {
        let input = DeleteCisScanConfigurationRequest(
            scanConfigurationArn: scanConfigurationArn
        )
        return try await self.deleteCisScanConfiguration(input, logger: logger)
    }

    /// Deletes a code security integration.
    @Sendable
    @inlinable
    public func deleteCodeSecurityIntegration(_ input: DeleteCodeSecurityIntegrationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCodeSecurityIntegrationResponse {
        try await self.client.execute(
            operation: "DeleteCodeSecurityIntegration", 
            path: "/codesecurity/integration/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a code security integration.
    ///
    /// Parameters:
    ///   - integrationArn: The Amazon Resource Name (ARN) of the code security integration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCodeSecurityIntegration(
        integrationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCodeSecurityIntegrationResponse {
        let input = DeleteCodeSecurityIntegrationRequest(
            integrationArn: integrationArn
        )
        return try await self.deleteCodeSecurityIntegration(input, logger: logger)
    }

    /// Deletes a code security scan configuration.
    @Sendable
    @inlinable
    public func deleteCodeSecurityScanConfiguration(_ input: DeleteCodeSecurityScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCodeSecurityScanConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteCodeSecurityScanConfiguration", 
            path: "/codesecurity/scan-configuration/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a code security scan configuration.
    ///
    /// Parameters:
    ///   - scanConfigurationArn: The Amazon Resource Name (ARN) of the scan configuration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCodeSecurityScanConfiguration(
        scanConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCodeSecurityScanConfigurationResponse {
        let input = DeleteCodeSecurityScanConfigurationRequest(
            scanConfigurationArn: scanConfigurationArn
        )
        return try await self.deleteCodeSecurityScanConfiguration(input, logger: logger)
    }

    /// Deletes a filter resource.
    @Sendable
    @inlinable
    public func deleteFilter(_ input: DeleteFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFilterResponse {
        try await self.client.execute(
            operation: "DeleteFilter", 
            path: "/filters/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a filter resource.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Number (ARN) of the filter to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFilter(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFilterResponse {
        let input = DeleteFilterRequest(
            arn: arn
        )
        return try await self.deleteFilter(input, logger: logger)
    }

    /// Describe Amazon Inspector configuration settings for an Amazon Web Services organization.
    @Sendable
    @inlinable
    public func describeOrganizationConfiguration(_ input: DescribeOrganizationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeOrganizationConfigurationResponse {
        try await self.client.execute(
            operation: "DescribeOrganizationConfiguration", 
            path: "/organizationconfiguration/describe", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describe Amazon Inspector configuration settings for an Amazon Web Services organization.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func describeOrganizationConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeOrganizationConfigurationResponse {
        let input = DescribeOrganizationConfigurationRequest(
        )
        return try await self.describeOrganizationConfiguration(input, logger: logger)
    }

    /// Disables Amazon Inspector scans for one or more Amazon Web Services accounts. Disabling all scan types in an account disables the Amazon Inspector service.
    @Sendable
    @inlinable
    public func disable(_ input: DisableRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableResponse {
        try await self.client.execute(
            operation: "Disable", 
            path: "/disable", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables Amazon Inspector scans for one or more Amazon Web Services accounts. Disabling all scan types in an account disables the Amazon Inspector service.
    ///
    /// Parameters:
    ///   - accountIds: An array of account IDs you want to disable Amazon Inspector scans for.
    ///   - resourceTypes: The resource scan types you want to disable.
    ///   - logger: Logger use during operation
    @inlinable
    public func disable(
        accountIds: [String]? = nil,
        resourceTypes: [ResourceScanType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableResponse {
        let input = DisableRequest(
            accountIds: accountIds, 
            resourceTypes: resourceTypes
        )
        return try await self.disable(input, logger: logger)
    }

    /// Disables the Amazon Inspector delegated administrator for your organization.
    @Sendable
    @inlinable
    public func disableDelegatedAdminAccount(_ input: DisableDelegatedAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableDelegatedAdminAccountResponse {
        try await self.client.execute(
            operation: "DisableDelegatedAdminAccount", 
            path: "/delegatedadminaccounts/disable", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the Amazon Inspector delegated administrator for your organization.
    ///
    /// Parameters:
    ///   - delegatedAdminAccountId: The Amazon Web Services account ID of the current Amazon Inspector delegated administrator.
    ///   - logger: Logger use during operation
    @inlinable
    public func disableDelegatedAdminAccount(
        delegatedAdminAccountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableDelegatedAdminAccountResponse {
        let input = DisableDelegatedAdminAccountRequest(
            delegatedAdminAccountId: delegatedAdminAccountId
        )
        return try await self.disableDelegatedAdminAccount(input, logger: logger)
    }

    /// Disassociates a member account from an Amazon Inspector delegated administrator.
    @Sendable
    @inlinable
    public func disassociateMember(_ input: DisassociateMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateMemberResponse {
        try await self.client.execute(
            operation: "DisassociateMember", 
            path: "/members/disassociate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a member account from an Amazon Inspector delegated administrator.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account ID of the member account to disassociate.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateMember(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateMemberResponse {
        let input = DisassociateMemberRequest(
            accountId: accountId
        )
        return try await self.disassociateMember(input, logger: logger)
    }

    /// Enables Amazon Inspector scans for one or more Amazon Web Services accounts.
    @Sendable
    @inlinable
    public func enable(_ input: EnableRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableResponse {
        try await self.client.execute(
            operation: "Enable", 
            path: "/enable", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables Amazon Inspector scans for one or more Amazon Web Services accounts.
    ///
    /// Parameters:
    ///   - accountIds: A list of account IDs you want to enable Amazon Inspector scans for.
    ///   - clientToken: The idempotency token for the request.
    ///   - resourceTypes: The resource scan types you want to enable.
    ///   - logger: Logger use during operation
    @inlinable
    public func enable(
        accountIds: [String]? = nil,
        clientToken: String? = EnableRequest.idempotencyToken(),
        resourceTypes: [ResourceScanType],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableResponse {
        let input = EnableRequest(
            accountIds: accountIds, 
            clientToken: clientToken, 
            resourceTypes: resourceTypes
        )
        return try await self.enable(input, logger: logger)
    }

    /// Enables the Amazon Inspector delegated administrator for your Organizations organization.
    @Sendable
    @inlinable
    public func enableDelegatedAdminAccount(_ input: EnableDelegatedAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableDelegatedAdminAccountResponse {
        try await self.client.execute(
            operation: "EnableDelegatedAdminAccount", 
            path: "/delegatedadminaccounts/enable", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the Amazon Inspector delegated administrator for your Organizations organization.
    ///
    /// Parameters:
    ///   - clientToken: The idempotency token for the request.
    ///   - delegatedAdminAccountId: The Amazon Web Services account ID of the Amazon Inspector delegated administrator.
    ///   - logger: Logger use during operation
    @inlinable
    public func enableDelegatedAdminAccount(
        clientToken: String? = EnableDelegatedAdminAccountRequest.idempotencyToken(),
        delegatedAdminAccountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableDelegatedAdminAccountResponse {
        let input = EnableDelegatedAdminAccountRequest(
            clientToken: clientToken, 
            delegatedAdminAccountId: delegatedAdminAccountId
        )
        return try await self.enableDelegatedAdminAccount(input, logger: logger)
    }

    /// Retrieves a CIS scan report.
    @Sendable
    @inlinable
    public func getCisScanReport(_ input: GetCisScanReportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCisScanReportResponse {
        try await self.client.execute(
            operation: "GetCisScanReport", 
            path: "/cis/scan/report/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a CIS scan report.
    ///
    /// Parameters:
    ///   - reportFormat:  The format of the report. Valid values are PDF and CSV. If no value is specified, the report format defaults to PDF.
    ///   - scanArn: The scan ARN.
    ///   - targetAccounts: The target accounts.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCisScanReport(
        reportFormat: CisReportFormat? = nil,
        scanArn: String,
        targetAccounts: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCisScanReportResponse {
        let input = GetCisScanReportRequest(
            reportFormat: reportFormat, 
            scanArn: scanArn, 
            targetAccounts: targetAccounts
        )
        return try await self.getCisScanReport(input, logger: logger)
    }

    /// Retrieves CIS scan result details.
    @Sendable
    @inlinable
    public func getCisScanResultDetails(_ input: GetCisScanResultDetailsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCisScanResultDetailsResponse {
        try await self.client.execute(
            operation: "GetCisScanResultDetails", 
            path: "/cis/scan-result/details/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves CIS scan result details.
    ///
    /// Parameters:
    ///   - accountId: The account ID.
    ///   - filterCriteria: The filter criteria.
    ///   - maxResults: The maximum number of CIS scan result details to be returned in a single page of results.
    ///   - nextToken: The pagination token from a previous request that's used to retrieve the next page of results.
    ///   - scanArn: The scan ARN.
    ///   - sortBy: The sort by order.
    ///   - sortOrder: The sort order.
    ///   - targetResourceId: The target resource ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCisScanResultDetails(
        accountId: String,
        filterCriteria: CisScanResultDetailsFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        scanArn: String,
        sortBy: CisScanResultDetailsSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        targetResourceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCisScanResultDetailsResponse {
        let input = GetCisScanResultDetailsRequest(
            accountId: accountId, 
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            scanArn: scanArn, 
            sortBy: sortBy, 
            sortOrder: sortOrder, 
            targetResourceId: targetResourceId
        )
        return try await self.getCisScanResultDetails(input, logger: logger)
    }

    /// Returns a list of clusters and metadata associated with an image.
    @Sendable
    @inlinable
    public func getClustersForImage(_ input: GetClustersForImageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetClustersForImageResponse {
        try await self.client.execute(
            operation: "GetClustersForImage", 
            path: "/cluster/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of clusters and metadata associated with an image.
    ///
    /// Parameters:
    ///   - filter: The resource Id for the Amazon ECR image.
    ///   - maxResults: The maximum number of results to be returned in a single page of results.
    ///   - nextToken: The pagination token from a previous request used to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getClustersForImage(
        filter: ClusterForImageFilterCriteria,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetClustersForImageResponse {
        let input = GetClustersForImageRequest(
            filter: filter, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getClustersForImage(input, logger: logger)
    }

    /// Retrieves information about a code security integration.
    @Sendable
    @inlinable
    public func getCodeSecurityIntegration(_ input: GetCodeSecurityIntegrationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCodeSecurityIntegrationResponse {
        try await self.client.execute(
            operation: "GetCodeSecurityIntegration", 
            path: "/codesecurity/integration/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a code security integration.
    ///
    /// Parameters:
    ///   - integrationArn: The Amazon Resource Name (ARN) of the code security integration to retrieve.
    ///   - tags: The tags associated with the code security integration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCodeSecurityIntegration(
        integrationArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCodeSecurityIntegrationResponse {
        let input = GetCodeSecurityIntegrationRequest(
            integrationArn: integrationArn, 
            tags: tags
        )
        return try await self.getCodeSecurityIntegration(input, logger: logger)
    }

    /// Retrieves information about a specific code security scan.
    @Sendable
    @inlinable
    public func getCodeSecurityScan(_ input: GetCodeSecurityScanRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCodeSecurityScanResponse {
        try await self.client.execute(
            operation: "GetCodeSecurityScan", 
            path: "/codesecurity/scan/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a specific code security scan.
    ///
    /// Parameters:
    ///   - resource: The resource identifier for the code repository that was scanned.
    ///   - scanId: The unique identifier of the scan to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCodeSecurityScan(
        resource: CodeSecurityResource,
        scanId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCodeSecurityScanResponse {
        let input = GetCodeSecurityScanRequest(
            resource: resource, 
            scanId: scanId
        )
        return try await self.getCodeSecurityScan(input, logger: logger)
    }

    /// Retrieves information about a code security scan configuration.
    @Sendable
    @inlinable
    public func getCodeSecurityScanConfiguration(_ input: GetCodeSecurityScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCodeSecurityScanConfigurationResponse {
        try await self.client.execute(
            operation: "GetCodeSecurityScanConfiguration", 
            path: "/codesecurity/scan-configuration/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a code security scan configuration.
    ///
    /// Parameters:
    ///   - scanConfigurationArn: The Amazon Resource Name (ARN) of the scan configuration to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCodeSecurityScanConfiguration(
        scanConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCodeSecurityScanConfigurationResponse {
        let input = GetCodeSecurityScanConfigurationRequest(
            scanConfigurationArn: scanConfigurationArn
        )
        return try await self.getCodeSecurityScanConfiguration(input, logger: logger)
    }

    /// Retrieves setting configurations for Inspector scans.
    @Sendable
    @inlinable
    public func getConfiguration(_ input: GetConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfigurationResponse {
        try await self.client.execute(
            operation: "GetConfiguration", 
            path: "/configuration/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves setting configurations for Inspector scans.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfigurationResponse {
        let input = GetConfigurationRequest(
        )
        return try await self.getConfiguration(input, logger: logger)
    }

    /// Retrieves information about the Amazon Inspector delegated administrator for your organization.
    @Sendable
    @inlinable
    public func getDelegatedAdminAccount(_ input: GetDelegatedAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDelegatedAdminAccountResponse {
        try await self.client.execute(
            operation: "GetDelegatedAdminAccount", 
            path: "/delegatedadminaccounts/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the Amazon Inspector delegated administrator for your organization.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getDelegatedAdminAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDelegatedAdminAccountResponse {
        let input = GetDelegatedAdminAccountRequest(
        )
        return try await self.getDelegatedAdminAccount(input, logger: logger)
    }

    /// Retrieves the activation status of Amazon Inspector deep inspection and custom paths associated with your account.
    @Sendable
    @inlinable
    public func getEc2DeepInspectionConfiguration(_ input: GetEc2DeepInspectionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEc2DeepInspectionConfigurationResponse {
        try await self.client.execute(
            operation: "GetEc2DeepInspectionConfiguration", 
            path: "/ec2deepinspectionconfiguration/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the activation status of Amazon Inspector deep inspection and custom paths associated with your account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getEc2DeepInspectionConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEc2DeepInspectionConfigurationResponse {
        let input = GetEc2DeepInspectionConfigurationRequest(
        )
        return try await self.getEc2DeepInspectionConfiguration(input, logger: logger)
    }

    /// Gets an encryption key.
    @Sendable
    @inlinable
    public func getEncryptionKey(_ input: GetEncryptionKeyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEncryptionKeyResponse {
        try await self.client.execute(
            operation: "GetEncryptionKey", 
            path: "/encryptionkey/get", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an encryption key.
    ///
    /// Parameters:
    ///   - resourceType: The resource type the key encrypts.
    ///   - scanType: The scan type the key encrypts.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEncryptionKey(
        resourceType: ResourceType,
        scanType: ScanType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEncryptionKeyResponse {
        let input = GetEncryptionKeyRequest(
            resourceType: resourceType, 
            scanType: scanType
        )
        return try await self.getEncryptionKey(input, logger: logger)
    }

    /// Gets the status of a findings report.
    @Sendable
    @inlinable
    public func getFindingsReportStatus(_ input: GetFindingsReportStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFindingsReportStatusResponse {
        try await self.client.execute(
            operation: "GetFindingsReportStatus", 
            path: "/reporting/status/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the status of a findings report.
    ///
    /// Parameters:
    ///   - reportId: The ID of the report to retrieve the status of.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFindingsReportStatus(
        reportId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFindingsReportStatusResponse {
        let input = GetFindingsReportStatusRequest(
            reportId: reportId
        )
        return try await self.getFindingsReportStatus(input, logger: logger)
    }

    /// Gets member information for your organization.
    @Sendable
    @inlinable
    public func getMember(_ input: GetMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMemberResponse {
        try await self.client.execute(
            operation: "GetMember", 
            path: "/members/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets member information for your organization.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account ID of the member account to retrieve information on.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMember(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMemberResponse {
        let input = GetMemberRequest(
            accountId: accountId
        )
        return try await self.getMember(input, logger: logger)
    }

    /// Gets details of a software bill of materials (SBOM) report.
    @Sendable
    @inlinable
    public func getSbomExport(_ input: GetSbomExportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSbomExportResponse {
        try await self.client.execute(
            operation: "GetSbomExport", 
            path: "/sbomexport/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details of a software bill of materials (SBOM) report.
    ///
    /// Parameters:
    ///   - reportId: The report ID of the SBOM export to get details for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSbomExport(
        reportId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSbomExportResponse {
        let input = GetSbomExportRequest(
            reportId: reportId
        )
        return try await self.getSbomExport(input, logger: logger)
    }

    /// Lists the permissions an account has to configure Amazon Inspector.
    @Sendable
    @inlinable
    public func listAccountPermissions(_ input: ListAccountPermissionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAccountPermissionsResponse {
        try await self.client.execute(
            operation: "ListAccountPermissions", 
            path: "/accountpermissions/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the permissions an account has to configure Amazon Inspector.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the NextToken value returned from the previous request to continue listing results after the first page.
    ///   - service: The service scan type to check permissions for.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAccountPermissions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        service: Service? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAccountPermissionsResponse {
        let input = ListAccountPermissionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            service: service
        )
        return try await self.listAccountPermissions(input, logger: logger)
    }

    /// Lists CIS scan configurations.
    @Sendable
    @inlinable
    public func listCisScanConfigurations(_ input: ListCisScanConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCisScanConfigurationsResponse {
        try await self.client.execute(
            operation: "ListCisScanConfigurations", 
            path: "/cis/scan-configuration/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists CIS scan configurations.
    ///
    /// Parameters:
    ///   - filterCriteria: The CIS scan configuration filter criteria.
    ///   - maxResults: The maximum number of CIS scan configurations to be returned in a single page of results.
    ///   - nextToken: The pagination token from a previous request that's used to retrieve the next page of results.
    ///   - sortBy: The CIS scan configuration sort by order.
    ///   - sortOrder: The CIS scan configuration sort order order.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCisScanConfigurations(
        filterCriteria: ListCisScanConfigurationsFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortBy: CisScanConfigurationsSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCisScanConfigurationsResponse {
        let input = ListCisScanConfigurationsRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return try await self.listCisScanConfigurations(input, logger: logger)
    }

    /// Lists scan results aggregated by checks.
    @Sendable
    @inlinable
    public func listCisScanResultsAggregatedByChecks(_ input: ListCisScanResultsAggregatedByChecksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCisScanResultsAggregatedByChecksResponse {
        try await self.client.execute(
            operation: "ListCisScanResultsAggregatedByChecks", 
            path: "/cis/scan-result/check/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists scan results aggregated by checks.
    ///
    /// Parameters:
    ///   - filterCriteria: The filter criteria.
    ///   - maxResults: The maximum number of scan results aggregated by checks to be returned in a single page of results.
    ///   - nextToken: The pagination token from a previous request that's used to retrieve the next page of results.
    ///   - scanArn: The scan ARN.
    ///   - sortBy: The sort by order.
    ///   - sortOrder: The sort order.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCisScanResultsAggregatedByChecks(
        filterCriteria: CisScanResultsAggregatedByChecksFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        scanArn: String,
        sortBy: CisScanResultsAggregatedByChecksSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCisScanResultsAggregatedByChecksResponse {
        let input = ListCisScanResultsAggregatedByChecksRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            scanArn: scanArn, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return try await self.listCisScanResultsAggregatedByChecks(input, logger: logger)
    }

    /// Lists scan results aggregated by a target resource.
    @Sendable
    @inlinable
    public func listCisScanResultsAggregatedByTargetResource(_ input: ListCisScanResultsAggregatedByTargetResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCisScanResultsAggregatedByTargetResourceResponse {
        try await self.client.execute(
            operation: "ListCisScanResultsAggregatedByTargetResource", 
            path: "/cis/scan-result/resource/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists scan results aggregated by a target resource.
    ///
    /// Parameters:
    ///   - filterCriteria: The filter criteria.
    ///   - maxResults: The maximum number of scan results aggregated by a target resource to be returned in a single page of results.
    ///   - nextToken: The pagination token from a previous request that's used to retrieve the next page of results.
    ///   - scanArn: The scan ARN.
    ///   - sortBy: The sort by order.
    ///   - sortOrder: The sort order.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCisScanResultsAggregatedByTargetResource(
        filterCriteria: CisScanResultsAggregatedByTargetResourceFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        scanArn: String,
        sortBy: CisScanResultsAggregatedByTargetResourceSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCisScanResultsAggregatedByTargetResourceResponse {
        let input = ListCisScanResultsAggregatedByTargetResourceRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            scanArn: scanArn, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return try await self.listCisScanResultsAggregatedByTargetResource(input, logger: logger)
    }

    /// Returns a CIS scan list.
    @Sendable
    @inlinable
    public func listCisScans(_ input: ListCisScansRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCisScansResponse {
        try await self.client.execute(
            operation: "ListCisScans", 
            path: "/cis/scan/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a CIS scan list.
    ///
    /// Parameters:
    ///   - detailLevel: The detail applied to the CIS scan.
    ///   - filterCriteria: The CIS scan filter criteria.
    ///   - maxResults: The maximum number of results to be returned.
    ///   - nextToken: The pagination token from a previous request that's used to retrieve the next page of results.
    ///   - sortBy: The CIS scans sort by order.
    ///   - sortOrder: The CIS scans sort order.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCisScans(
        detailLevel: ListCisScansDetailLevel? = nil,
        filterCriteria: ListCisScansFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortBy: ListCisScansSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCisScansResponse {
        let input = ListCisScansRequest(
            detailLevel: detailLevel, 
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return try await self.listCisScans(input, logger: logger)
    }

    /// Lists all code security integrations in your account.
    @Sendable
    @inlinable
    public func listCodeSecurityIntegrations(_ input: ListCodeSecurityIntegrationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCodeSecurityIntegrationsResponse {
        try await self.client.execute(
            operation: "ListCodeSecurityIntegrations", 
            path: "/codesecurity/integration/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all code security integrations in your account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request. For subsequent calls, use the NextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCodeSecurityIntegrations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCodeSecurityIntegrationsResponse {
        let input = ListCodeSecurityIntegrationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCodeSecurityIntegrations(input, logger: logger)
    }

    /// Lists the associations between code repositories and Amazon Inspector code security scan configurations.
    @Sendable
    @inlinable
    public func listCodeSecurityScanConfigurationAssociations(_ input: ListCodeSecurityScanConfigurationAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCodeSecurityScanConfigurationAssociationsResponse {
        try await self.client.execute(
            operation: "ListCodeSecurityScanConfigurationAssociations", 
            path: "/codesecurity/scan-configuration/associations/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the associations between code repositories and Amazon Inspector code security scan configurations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in the response. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. For subsequent calls, use the NextToken value returned from the previous request to continue listing results after the first page.
    ///   - scanConfigurationArn: The Amazon Resource Name (ARN) of the scan configuration to list associations for.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCodeSecurityScanConfigurationAssociations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        scanConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCodeSecurityScanConfigurationAssociationsResponse {
        let input = ListCodeSecurityScanConfigurationAssociationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            scanConfigurationArn: scanConfigurationArn
        )
        return try await self.listCodeSecurityScanConfigurationAssociations(input, logger: logger)
    }

    /// Lists all code security scan configurations in your account.
    @Sendable
    @inlinable
    public func listCodeSecurityScanConfigurations(_ input: ListCodeSecurityScanConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCodeSecurityScanConfigurationsResponse {
        try await self.client.execute(
            operation: "ListCodeSecurityScanConfigurations", 
            path: "/codesecurity/scan-configuration/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all code security scan configurations in your account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request. For subsequent calls, use the NextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCodeSecurityScanConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCodeSecurityScanConfigurationsResponse {
        let input = ListCodeSecurityScanConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCodeSecurityScanConfigurations(input, logger: logger)
    }

    /// Lists coverage details for your environment.
    @Sendable
    @inlinable
    public func listCoverage(_ input: ListCoverageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCoverageResponse {
        try await self.client.execute(
            operation: "ListCoverage", 
            path: "/coverage/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists coverage details for your environment.
    ///
    /// Parameters:
    ///   - filterCriteria: An object that contains details on the filters to apply to the coverage data for your environment.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCoverage(
        filterCriteria: CoverageFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCoverageResponse {
        let input = ListCoverageRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCoverage(input, logger: logger)
    }

    /// Lists Amazon Inspector coverage statistics for your environment.
    @Sendable
    @inlinable
    public func listCoverageStatistics(_ input: ListCoverageStatisticsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCoverageStatisticsResponse {
        try await self.client.execute(
            operation: "ListCoverageStatistics", 
            path: "/coverage/statistics/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists Amazon Inspector coverage statistics for your environment.
    ///
    /// Parameters:
    ///   - filterCriteria: An object that contains details on the filters to apply to the coverage data for your environment.
    ///   - groupBy: The value to group the results by.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. For subsequent calls, use the NextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCoverageStatistics(
        filterCriteria: CoverageFilterCriteria? = nil,
        groupBy: GroupKey? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCoverageStatisticsResponse {
        let input = ListCoverageStatisticsRequest(
            filterCriteria: filterCriteria, 
            groupBy: groupBy, 
            nextToken: nextToken
        )
        return try await self.listCoverageStatistics(input, logger: logger)
    }

    /// Lists information about the Amazon Inspector delegated administrator of your organization.
    @Sendable
    @inlinable
    public func listDelegatedAdminAccounts(_ input: ListDelegatedAdminAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDelegatedAdminAccountsResponse {
        try await self.client.execute(
            operation: "ListDelegatedAdminAccounts", 
            path: "/delegatedadminaccounts/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about the Amazon Inspector delegated administrator of your organization.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDelegatedAdminAccounts(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDelegatedAdminAccountsResponse {
        let input = ListDelegatedAdminAccountsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDelegatedAdminAccounts(input, logger: logger)
    }

    /// Lists the filters associated with your account.
    @Sendable
    @inlinable
    public func listFilters(_ input: ListFiltersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFiltersResponse {
        try await self.client.execute(
            operation: "ListFilters", 
            path: "/filters/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the filters associated with your account.
    ///
    /// Parameters:
    ///   - action: The action the filter applies to matched findings.
    ///   - arns: The Amazon resource number (ARN) of the filter.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFilters(
        action: FilterAction? = nil,
        arns: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFiltersResponse {
        let input = ListFiltersRequest(
            action: action, 
            arns: arns, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFilters(input, logger: logger)
    }

    /// Lists aggregated finding data for your environment based on specific criteria.
    @Sendable
    @inlinable
    public func listFindingAggregations(_ input: ListFindingAggregationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFindingAggregationsResponse {
        try await self.client.execute(
            operation: "ListFindingAggregations", 
            path: "/findings/aggregation/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists aggregated finding data for your environment based on specific criteria.
    ///
    /// Parameters:
    ///   - accountIds: The Amazon Web Services account IDs to retrieve finding aggregation data for.
    ///   - aggregationRequest: Details of the aggregation request that is used to filter your aggregation results.
    ///   - aggregationType: The type of the aggregation request.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFindingAggregations(
        accountIds: [StringFilter]? = nil,
        aggregationRequest: AggregationRequest? = nil,
        aggregationType: AggregationType,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFindingAggregationsResponse {
        let input = ListFindingAggregationsRequest(
            accountIds: accountIds, 
            aggregationRequest: aggregationRequest, 
            aggregationType: aggregationType, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFindingAggregations(input, logger: logger)
    }

    /// Lists findings for your environment.
    @Sendable
    @inlinable
    public func listFindings(_ input: ListFindingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFindingsResponse {
        try await self.client.execute(
            operation: "ListFindings", 
            path: "/findings/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists findings for your environment.
    ///
    /// Parameters:
    ///   - filterCriteria: Details on the filters to apply to your finding results.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - sortCriteria: Details on the sort criteria to apply to your finding results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFindings(
        filterCriteria: FilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortCriteria: SortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFindingsResponse {
        let input = ListFindingsRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortCriteria: sortCriteria
        )
        return try await self.listFindings(input, logger: logger)
    }

    /// List members associated with the Amazon Inspector delegated administrator for your organization.
    @Sendable
    @inlinable
    public func listMembers(_ input: ListMembersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMembersResponse {
        try await self.client.execute(
            operation: "ListMembers", 
            path: "/members/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List members associated with the Amazon Inspector delegated administrator for your organization.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - onlyAssociated: Specifies whether to list only currently associated members if True or to list all members within the organization if False.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMembers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        onlyAssociated: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMembersResponse {
        let input = ListMembersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            onlyAssociated: onlyAssociated
        )
        return try await self.listMembers(input, logger: logger)
    }

    /// Lists all tags attached to a given resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all tags attached to a given resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon resource number (ARN) of the resource to list tags of.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists the Amazon Inspector usage totals over the last 30 days.
    @Sendable
    @inlinable
    public func listUsageTotals(_ input: ListUsageTotalsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUsageTotalsResponse {
        try await self.client.execute(
            operation: "ListUsageTotals", 
            path: "/usage/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Amazon Inspector usage totals over the last 30 days.
    ///
    /// Parameters:
    ///   - accountIds: The Amazon Web Services account IDs to retrieve usage totals for.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. If your response returns more than the maxResults maximum value it will also return a nextToken value. For subsequent calls, use the nextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUsageTotals(
        accountIds: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUsageTotalsResponse {
        let input = ListUsageTotalsRequest(
            accountIds: accountIds, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUsageTotals(input, logger: logger)
    }

    /// Resets an encryption key. After the key is reset your resources will be encrypted by an Amazon Web Services owned key.
    @Sendable
    @inlinable
    public func resetEncryptionKey(_ input: ResetEncryptionKeyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResetEncryptionKeyResponse {
        try await self.client.execute(
            operation: "ResetEncryptionKey", 
            path: "/encryptionkey/reset", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Resets an encryption key. After the key is reset your resources will be encrypted by an Amazon Web Services owned key.
    ///
    /// Parameters:
    ///   - resourceType: The resource type the key encrypts.
    ///   - scanType: The scan type the key encrypts.
    ///   - logger: Logger use during operation
    @inlinable
    public func resetEncryptionKey(
        resourceType: ResourceType,
        scanType: ScanType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResetEncryptionKeyResponse {
        let input = ResetEncryptionKeyRequest(
            resourceType: resourceType, 
            scanType: scanType
        )
        return try await self.resetEncryptionKey(input, logger: logger)
    }

    /// Lists Amazon Inspector coverage details for a specific vulnerability.
    @Sendable
    @inlinable
    public func searchVulnerabilities(_ input: SearchVulnerabilitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchVulnerabilitiesResponse {
        try await self.client.execute(
            operation: "SearchVulnerabilities", 
            path: "/vulnerabilities/search", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists Amazon Inspector coverage details for a specific vulnerability.
    ///
    /// Parameters:
    ///   - filterCriteria: The criteria used to filter the results of a vulnerability search.
    ///   - nextToken: A token to use for paginating results that are returned in the response. Set the value of this parameter to null for the first request to a list action. For subsequent calls, use the NextToken value returned from the previous request to continue listing results after the first page.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchVulnerabilities(
        filterCriteria: SearchVulnerabilitiesFilterCriteria,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchVulnerabilitiesResponse {
        let input = SearchVulnerabilitiesRequest(
            filterCriteria: filterCriteria, 
            nextToken: nextToken
        )
        return try await self.searchVulnerabilities(input, logger: logger)
    }

    ///  Sends a CIS session health. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to start a CIS scan session for the scan ID supplied by the service.
    @Sendable
    @inlinable
    public func sendCisSessionHealth(_ input: SendCisSessionHealthRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendCisSessionHealthResponse {
        try await self.client.execute(
            operation: "SendCisSessionHealth", 
            path: "/cissession/health/send", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Sends a CIS session health. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to start a CIS scan session for the scan ID supplied by the service.
    ///
    /// Parameters:
    ///   - scanJobId: A unique identifier for the scan job.
    ///   - sessionToken: The unique token that identifies the CIS session.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendCisSessionHealth(
        scanJobId: String,
        sessionToken: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendCisSessionHealthResponse {
        let input = SendCisSessionHealthRequest(
            scanJobId: scanJobId, 
            sessionToken: sessionToken
        )
        return try await self.sendCisSessionHealth(input, logger: logger)
    }

    ///  Sends a CIS session telemetry. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to start a CIS scan session for the scan ID supplied by the service.
    @Sendable
    @inlinable
    public func sendCisSessionTelemetry(_ input: SendCisSessionTelemetryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendCisSessionTelemetryResponse {
        try await self.client.execute(
            operation: "SendCisSessionTelemetry", 
            path: "/cissession/telemetry/send", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Sends a CIS session telemetry. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to start a CIS scan session for the scan ID supplied by the service.
    ///
    /// Parameters:
    ///   - messages: The CIS session telemetry messages.
    ///   - scanJobId: A unique identifier for the scan job.
    ///   - sessionToken: The unique token that identifies the CIS session.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendCisSessionTelemetry(
        messages: [CisSessionMessage],
        scanJobId: String,
        sessionToken: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendCisSessionTelemetryResponse {
        let input = SendCisSessionTelemetryRequest(
            messages: messages, 
            scanJobId: scanJobId, 
            sessionToken: sessionToken
        )
        return try await self.sendCisSessionTelemetry(input, logger: logger)
    }

    ///  Starts a CIS session. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to start a CIS scan session for the scan ID supplied by the service.
    @Sendable
    @inlinable
    public func startCisSession(_ input: StartCisSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartCisSessionResponse {
        try await self.client.execute(
            operation: "StartCisSession", 
            path: "/cissession/start", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Starts a CIS session. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to start a CIS scan session for the scan ID supplied by the service.
    ///
    /// Parameters:
    ///   - message: The start CIS session message.
    ///   - scanJobId: A unique identifier for the scan job.
    ///   - logger: Logger use during operation
    @inlinable
    public func startCisSession(
        message: StartCisSessionMessage,
        scanJobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartCisSessionResponse {
        let input = StartCisSessionRequest(
            message: message, 
            scanJobId: scanJobId
        )
        return try await self.startCisSession(input, logger: logger)
    }

    /// Initiates a code security scan on a specified repository.
    @Sendable
    @inlinable
    public func startCodeSecurityScan(_ input: StartCodeSecurityScanRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartCodeSecurityScanResponse {
        try await self.client.execute(
            operation: "StartCodeSecurityScan", 
            path: "/codesecurity/scan/start", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a code security scan on a specified repository.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - resource: The resource identifier for the code repository to scan.
    ///   - logger: Logger use during operation
    @inlinable
    public func startCodeSecurityScan(
        clientToken: String? = StartCodeSecurityScanRequest.idempotencyToken(),
        resource: CodeSecurityResource,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartCodeSecurityScanResponse {
        let input = StartCodeSecurityScanRequest(
            clientToken: clientToken, 
            resource: resource
        )
        return try await self.startCodeSecurityScan(input, logger: logger)
    }

    ///  Stops a CIS session. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to stop a CIS scan session for the scan ID supplied by the service.
    @Sendable
    @inlinable
    public func stopCisSession(_ input: StopCisSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopCisSessionResponse {
        try await self.client.execute(
            operation: "StopCisSession", 
            path: "/cissession/stop", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Stops a CIS session. This API is used by the Amazon Inspector SSM plugin to communicate with the Amazon Inspector service. The Amazon Inspector SSM plugin calls this API to stop a CIS scan session for the scan ID supplied by the service.
    ///
    /// Parameters:
    ///   - message: The stop CIS session message.
    ///   - scanJobId: A unique identifier for the scan job.
    ///   - sessionToken: The unique token that identifies the CIS session.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopCisSession(
        message: StopCisSessionMessage,
        scanJobId: String,
        sessionToken: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopCisSessionResponse {
        let input = StopCisSessionRequest(
            message: message, 
            scanJobId: scanJobId, 
            sessionToken: sessionToken
        )
        return try await self.stopCisSession(input, logger: logger)
    }

    /// Adds tags to a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds tags to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to apply a tag to.
    ///   - tags: The tags to be added to a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) for the resource to remove tags from.
    ///   - tagKeys: The tag keys to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates a CIS scan configuration.
    @Sendable
    @inlinable
    public func updateCisScanConfiguration(_ input: UpdateCisScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCisScanConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateCisScanConfiguration", 
            path: "/cis/scan-configuration/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a CIS scan configuration.
    ///
    /// Parameters:
    ///   - scanConfigurationArn: The CIS scan configuration ARN.
    ///   - scanName: The scan name for the CIS scan configuration.
    ///   - schedule: The schedule for the CIS scan configuration.
    ///   - securityLevel:  The security level for the CIS scan configuration. Security level refers to the Benchmark levels that CIS assigns to a profile.
    ///   - targets: The targets for the CIS scan configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCisScanConfiguration(
        scanConfigurationArn: String,
        scanName: String? = nil,
        schedule: Schedule? = nil,
        securityLevel: CisSecurityLevel? = nil,
        targets: UpdateCisTargets? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCisScanConfigurationResponse {
        let input = UpdateCisScanConfigurationRequest(
            scanConfigurationArn: scanConfigurationArn, 
            scanName: scanName, 
            schedule: schedule, 
            securityLevel: securityLevel, 
            targets: targets
        )
        return try await self.updateCisScanConfiguration(input, logger: logger)
    }

    /// Updates an existing code security integration. After calling the CreateCodeSecurityIntegration operation, you complete authentication and authorization with your provider. Next you call the UpdateCodeSecurityIntegration operation to provide the details to complete the integration setup
    @Sendable
    @inlinable
    public func updateCodeSecurityIntegration(_ input: UpdateCodeSecurityIntegrationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCodeSecurityIntegrationResponse {
        try await self.client.execute(
            operation: "UpdateCodeSecurityIntegration", 
            path: "/codesecurity/integration/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing code security integration. After calling the CreateCodeSecurityIntegration operation, you complete authentication and authorization with your provider. Next you call the UpdateCodeSecurityIntegration operation to provide the details to complete the integration setup
    ///
    /// Parameters:
    ///   - details: The updated integration details specific to the repository provider type.
    ///   - integrationArn: The Amazon Resource Name (ARN) of the code security integration to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCodeSecurityIntegration(
        details: UpdateIntegrationDetails,
        integrationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCodeSecurityIntegrationResponse {
        let input = UpdateCodeSecurityIntegrationRequest(
            details: details, 
            integrationArn: integrationArn
        )
        return try await self.updateCodeSecurityIntegration(input, logger: logger)
    }

    /// Updates an existing code security scan configuration.
    @Sendable
    @inlinable
    public func updateCodeSecurityScanConfiguration(_ input: UpdateCodeSecurityScanConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCodeSecurityScanConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateCodeSecurityScanConfiguration", 
            path: "/codesecurity/scan-configuration/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing code security scan configuration.
    ///
    /// Parameters:
    ///   - configuration: The updated configuration settings for the code security scan.
    ///   - scanConfigurationArn: The Amazon Resource Name (ARN) of the scan configuration to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCodeSecurityScanConfiguration(
        configuration: CodeSecurityScanConfiguration,
        scanConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCodeSecurityScanConfigurationResponse {
        let input = UpdateCodeSecurityScanConfigurationRequest(
            configuration: configuration, 
            scanConfigurationArn: scanConfigurationArn
        )
        return try await self.updateCodeSecurityScanConfiguration(input, logger: logger)
    }

    /// Updates setting configurations for your Amazon Inspector account. When you use this API as an Amazon Inspector delegated administrator this updates the setting for all accounts you manage. Member accounts in an organization cannot update this setting.
    @Sendable
    @inlinable
    public func updateConfiguration(_ input: UpdateConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateConfiguration", 
            path: "/configuration/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates setting configurations for your Amazon Inspector account. When you use this API as an Amazon Inspector delegated administrator this updates the setting for all accounts you manage. Member accounts in an organization cannot update this setting.
    ///
    /// Parameters:
    ///   - ec2Configuration: Specifies how the Amazon EC2 automated scan will be updated for your environment.
    ///   - ecrConfiguration: Specifies how the ECR automated re-scan will be updated for your environment.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConfiguration(
        ec2Configuration: Ec2Configuration? = nil,
        ecrConfiguration: EcrConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConfigurationResponse {
        let input = UpdateConfigurationRequest(
            ec2Configuration: ec2Configuration, 
            ecrConfiguration: ecrConfiguration
        )
        return try await self.updateConfiguration(input, logger: logger)
    }

    /// Activates, deactivates Amazon Inspector deep inspection, or updates custom paths for your account.
    @Sendable
    @inlinable
    public func updateEc2DeepInspectionConfiguration(_ input: UpdateEc2DeepInspectionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEc2DeepInspectionConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateEc2DeepInspectionConfiguration", 
            path: "/ec2deepinspectionconfiguration/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Activates, deactivates Amazon Inspector deep inspection, or updates custom paths for your account.
    ///
    /// Parameters:
    ///   - activateDeepInspection: Specify TRUE to activate Amazon Inspector deep inspection in your account, or FALSE to deactivate. Member accounts in an organization cannot deactivate deep inspection, instead the delegated administrator for the organization can deactivate a member account using BatchUpdateMemberEc2DeepInspectionStatus.
    ///   - packagePaths: The Amazon Inspector deep inspection custom paths you are adding for your account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEc2DeepInspectionConfiguration(
        activateDeepInspection: Bool? = nil,
        packagePaths: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEc2DeepInspectionConfigurationResponse {
        let input = UpdateEc2DeepInspectionConfigurationRequest(
            activateDeepInspection: activateDeepInspection, 
            packagePaths: packagePaths
        )
        return try await self.updateEc2DeepInspectionConfiguration(input, logger: logger)
    }

    /// Updates an encryption key. A ResourceNotFoundException means that an Amazon Web Services owned key is being used for encryption.
    @Sendable
    @inlinable
    public func updateEncryptionKey(_ input: UpdateEncryptionKeyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEncryptionKeyResponse {
        try await self.client.execute(
            operation: "UpdateEncryptionKey", 
            path: "/encryptionkey/update", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an encryption key. A ResourceNotFoundException means that an Amazon Web Services owned key is being used for encryption.
    ///
    /// Parameters:
    ///   - kmsKeyId: A KMS key ID for the encryption key.
    ///   - resourceType: The resource type for the encryption key.
    ///   - scanType: The scan type for the encryption key.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEncryptionKey(
        kmsKeyId: String,
        resourceType: ResourceType,
        scanType: ScanType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEncryptionKeyResponse {
        let input = UpdateEncryptionKeyRequest(
            kmsKeyId: kmsKeyId, 
            resourceType: resourceType, 
            scanType: scanType
        )
        return try await self.updateEncryptionKey(input, logger: logger)
    }

    /// Specifies the action that is to be applied to the findings that match the filter.
    @Sendable
    @inlinable
    public func updateFilter(_ input: UpdateFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFilterResponse {
        try await self.client.execute(
            operation: "UpdateFilter", 
            path: "/filters/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Specifies the action that is to be applied to the findings that match the filter.
    ///
    /// Parameters:
    ///   - action: Specifies the action that is to be applied to the findings that match the filter.
    ///   - description: A description of the filter.
    ///   - filterArn: The Amazon Resource Number (ARN) of the filter to update.
    ///   - filterCriteria: Defines the criteria to be update in the filter.
    ///   - name: The name of the filter.
    ///   - reason: The reason the filter was updated.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFilter(
        action: FilterAction? = nil,
        description: String? = nil,
        filterArn: String,
        filterCriteria: FilterCriteria? = nil,
        name: String? = nil,
        reason: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFilterResponse {
        let input = UpdateFilterRequest(
            action: action, 
            description: description, 
            filterArn: filterArn, 
            filterCriteria: filterCriteria, 
            name: name, 
            reason: reason
        )
        return try await self.updateFilter(input, logger: logger)
    }

    /// Updates the Amazon Inspector deep inspection custom paths for your organization. You must be an Amazon Inspector delegated administrator to use this API.
    @Sendable
    @inlinable
    public func updateOrgEc2DeepInspectionConfiguration(_ input: UpdateOrgEc2DeepInspectionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateOrgEc2DeepInspectionConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateOrgEc2DeepInspectionConfiguration", 
            path: "/ec2deepinspectionconfiguration/org/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Amazon Inspector deep inspection custom paths for your organization. You must be an Amazon Inspector delegated administrator to use this API.
    ///
    /// Parameters:
    ///   - orgPackagePaths: The Amazon Inspector deep inspection custom paths you are adding for your organization.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateOrgEc2DeepInspectionConfiguration(
        orgPackagePaths: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateOrgEc2DeepInspectionConfigurationResponse {
        let input = UpdateOrgEc2DeepInspectionConfigurationRequest(
            orgPackagePaths: orgPackagePaths
        )
        return try await self.updateOrgEc2DeepInspectionConfiguration(input, logger: logger)
    }

    /// Updates the configurations for your Amazon Inspector organization.
    @Sendable
    @inlinable
    public func updateOrganizationConfiguration(_ input: UpdateOrganizationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateOrganizationConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateOrganizationConfiguration", 
            path: "/organizationconfiguration/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the configurations for your Amazon Inspector organization.
    ///
    /// Parameters:
    ///   - autoEnable: Defines which scan types are enabled automatically for new members of your Amazon Inspector organization.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateOrganizationConfiguration(
        autoEnable: AutoEnable,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateOrganizationConfigurationResponse {
        let input = UpdateOrganizationConfigurationRequest(
            autoEnable: autoEnable
        )
        return try await self.updateOrganizationConfiguration(input, logger: logger)
    }
}

extension Inspector2 {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Inspector2, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Inspector2 {
    /// Return PaginatorSequence for operation ``getCisScanResultDetails(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCisScanResultDetailsPaginator(
        _ input: GetCisScanResultDetailsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCisScanResultDetailsRequest, GetCisScanResultDetailsResponse> {
        return .init(
            input: input,
            command: self.getCisScanResultDetails,
            inputKey: \GetCisScanResultDetailsRequest.nextToken,
            outputKey: \GetCisScanResultDetailsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCisScanResultDetails(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The account ID.
    ///   - filterCriteria: The filter criteria.
    ///   - maxResults: The maximum number of CIS scan result details to be returned in a single page of results.
    ///   - scanArn: The scan ARN.
    ///   - sortBy: The sort by order.
    ///   - sortOrder: The sort order.
    ///   - targetResourceId: The target resource ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCisScanResultDetailsPaginator(
        accountId: String,
        filterCriteria: CisScanResultDetailsFilterCriteria? = nil,
        maxResults: Int? = nil,
        scanArn: String,
        sortBy: CisScanResultDetailsSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        targetResourceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCisScanResultDetailsRequest, GetCisScanResultDetailsResponse> {
        let input = GetCisScanResultDetailsRequest(
            accountId: accountId, 
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            scanArn: scanArn, 
            sortBy: sortBy, 
            sortOrder: sortOrder, 
            targetResourceId: targetResourceId
        )
        return self.getCisScanResultDetailsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getClustersForImage(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getClustersForImagePaginator(
        _ input: GetClustersForImageRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetClustersForImageRequest, GetClustersForImageResponse> {
        return .init(
            input: input,
            command: self.getClustersForImage,
            inputKey: \GetClustersForImageRequest.nextToken,
            outputKey: \GetClustersForImageResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getClustersForImage(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filter: The resource Id for the Amazon ECR image.
    ///   - maxResults: The maximum number of results to be returned in a single page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func getClustersForImagePaginator(
        filter: ClusterForImageFilterCriteria,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetClustersForImageRequest, GetClustersForImageResponse> {
        let input = GetClustersForImageRequest(
            filter: filter, 
            maxResults: maxResults
        )
        return self.getClustersForImagePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAccountPermissions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountPermissionsPaginator(
        _ input: ListAccountPermissionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAccountPermissionsRequest, ListAccountPermissionsResponse> {
        return .init(
            input: input,
            command: self.listAccountPermissions,
            inputKey: \ListAccountPermissionsRequest.nextToken,
            outputKey: \ListAccountPermissionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAccountPermissions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - service: The service scan type to check permissions for.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountPermissionsPaginator(
        maxResults: Int? = nil,
        service: Service? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAccountPermissionsRequest, ListAccountPermissionsResponse> {
        let input = ListAccountPermissionsRequest(
            maxResults: maxResults, 
            service: service
        )
        return self.listAccountPermissionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCisScanConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScanConfigurationsPaginator(
        _ input: ListCisScanConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCisScanConfigurationsRequest, ListCisScanConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listCisScanConfigurations,
            inputKey: \ListCisScanConfigurationsRequest.nextToken,
            outputKey: \ListCisScanConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCisScanConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: The CIS scan configuration filter criteria.
    ///   - maxResults: The maximum number of CIS scan configurations to be returned in a single page of results.
    ///   - sortBy: The CIS scan configuration sort by order.
    ///   - sortOrder: The CIS scan configuration sort order order.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScanConfigurationsPaginator(
        filterCriteria: ListCisScanConfigurationsFilterCriteria? = nil,
        maxResults: Int? = nil,
        sortBy: CisScanConfigurationsSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCisScanConfigurationsRequest, ListCisScanConfigurationsResponse> {
        let input = ListCisScanConfigurationsRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return self.listCisScanConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCisScanResultsAggregatedByChecks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScanResultsAggregatedByChecksPaginator(
        _ input: ListCisScanResultsAggregatedByChecksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCisScanResultsAggregatedByChecksRequest, ListCisScanResultsAggregatedByChecksResponse> {
        return .init(
            input: input,
            command: self.listCisScanResultsAggregatedByChecks,
            inputKey: \ListCisScanResultsAggregatedByChecksRequest.nextToken,
            outputKey: \ListCisScanResultsAggregatedByChecksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCisScanResultsAggregatedByChecks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: The filter criteria.
    ///   - maxResults: The maximum number of scan results aggregated by checks to be returned in a single page of results.
    ///   - scanArn: The scan ARN.
    ///   - sortBy: The sort by order.
    ///   - sortOrder: The sort order.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScanResultsAggregatedByChecksPaginator(
        filterCriteria: CisScanResultsAggregatedByChecksFilterCriteria? = nil,
        maxResults: Int? = nil,
        scanArn: String,
        sortBy: CisScanResultsAggregatedByChecksSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCisScanResultsAggregatedByChecksRequest, ListCisScanResultsAggregatedByChecksResponse> {
        let input = ListCisScanResultsAggregatedByChecksRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            scanArn: scanArn, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return self.listCisScanResultsAggregatedByChecksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCisScanResultsAggregatedByTargetResource(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScanResultsAggregatedByTargetResourcePaginator(
        _ input: ListCisScanResultsAggregatedByTargetResourceRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCisScanResultsAggregatedByTargetResourceRequest, ListCisScanResultsAggregatedByTargetResourceResponse> {
        return .init(
            input: input,
            command: self.listCisScanResultsAggregatedByTargetResource,
            inputKey: \ListCisScanResultsAggregatedByTargetResourceRequest.nextToken,
            outputKey: \ListCisScanResultsAggregatedByTargetResourceResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCisScanResultsAggregatedByTargetResource(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: The filter criteria.
    ///   - maxResults: The maximum number of scan results aggregated by a target resource to be returned in a single page of results.
    ///   - scanArn: The scan ARN.
    ///   - sortBy: The sort by order.
    ///   - sortOrder: The sort order.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScanResultsAggregatedByTargetResourcePaginator(
        filterCriteria: CisScanResultsAggregatedByTargetResourceFilterCriteria? = nil,
        maxResults: Int? = nil,
        scanArn: String,
        sortBy: CisScanResultsAggregatedByTargetResourceSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCisScanResultsAggregatedByTargetResourceRequest, ListCisScanResultsAggregatedByTargetResourceResponse> {
        let input = ListCisScanResultsAggregatedByTargetResourceRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            scanArn: scanArn, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return self.listCisScanResultsAggregatedByTargetResourcePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCisScans(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScansPaginator(
        _ input: ListCisScansRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCisScansRequest, ListCisScansResponse> {
        return .init(
            input: input,
            command: self.listCisScans,
            inputKey: \ListCisScansRequest.nextToken,
            outputKey: \ListCisScansResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCisScans(_:logger:)``.
    ///
    /// - Parameters:
    ///   - detailLevel: The detail applied to the CIS scan.
    ///   - filterCriteria: The CIS scan filter criteria.
    ///   - maxResults: The maximum number of results to be returned.
    ///   - sortBy: The CIS scans sort by order.
    ///   - sortOrder: The CIS scans sort order.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCisScansPaginator(
        detailLevel: ListCisScansDetailLevel? = nil,
        filterCriteria: ListCisScansFilterCriteria? = nil,
        maxResults: Int? = nil,
        sortBy: ListCisScansSortBy? = nil,
        sortOrder: CisSortOrder? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCisScansRequest, ListCisScansResponse> {
        let input = ListCisScansRequest(
            detailLevel: detailLevel, 
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            sortBy: sortBy, 
            sortOrder: sortOrder
        )
        return self.listCisScansPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCoverage(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoveragePaginator(
        _ input: ListCoverageRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCoverageRequest, ListCoverageResponse> {
        return .init(
            input: input,
            command: self.listCoverage,
            inputKey: \ListCoverageRequest.nextToken,
            outputKey: \ListCoverageResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCoverage(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: An object that contains details on the filters to apply to the coverage data for your environment.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoveragePaginator(
        filterCriteria: CoverageFilterCriteria? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCoverageRequest, ListCoverageResponse> {
        let input = ListCoverageRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults
        )
        return self.listCoveragePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCoverageStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoverageStatisticsPaginator(
        _ input: ListCoverageStatisticsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCoverageStatisticsRequest, ListCoverageStatisticsResponse> {
        return .init(
            input: input,
            command: self.listCoverageStatistics,
            inputKey: \ListCoverageStatisticsRequest.nextToken,
            outputKey: \ListCoverageStatisticsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCoverageStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: An object that contains details on the filters to apply to the coverage data for your environment.
    ///   - groupBy: The value to group the results by.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoverageStatisticsPaginator(
        filterCriteria: CoverageFilterCriteria? = nil,
        groupBy: GroupKey? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCoverageStatisticsRequest, ListCoverageStatisticsResponse> {
        let input = ListCoverageStatisticsRequest(
            filterCriteria: filterCriteria, 
            groupBy: groupBy
        )
        return self.listCoverageStatisticsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDelegatedAdminAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDelegatedAdminAccountsPaginator(
        _ input: ListDelegatedAdminAccountsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDelegatedAdminAccountsRequest, ListDelegatedAdminAccountsResponse> {
        return .init(
            input: input,
            command: self.listDelegatedAdminAccounts,
            inputKey: \ListDelegatedAdminAccountsRequest.nextToken,
            outputKey: \ListDelegatedAdminAccountsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDelegatedAdminAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDelegatedAdminAccountsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDelegatedAdminAccountsRequest, ListDelegatedAdminAccountsResponse> {
        let input = ListDelegatedAdminAccountsRequest(
            maxResults: maxResults
        )
        return self.listDelegatedAdminAccountsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFilters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFiltersPaginator(
        _ input: ListFiltersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFiltersRequest, ListFiltersResponse> {
        return .init(
            input: input,
            command: self.listFilters,
            inputKey: \ListFiltersRequest.nextToken,
            outputKey: \ListFiltersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFilters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - action: The action the filter applies to matched findings.
    ///   - arns: The Amazon resource number (ARN) of the filter.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFiltersPaginator(
        action: FilterAction? = nil,
        arns: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFiltersRequest, ListFiltersResponse> {
        let input = ListFiltersRequest(
            action: action, 
            arns: arns, 
            maxResults: maxResults
        )
        return self.listFiltersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFindingAggregations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingAggregationsPaginator(
        _ input: ListFindingAggregationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFindingAggregationsRequest, ListFindingAggregationsResponse> {
        return .init(
            input: input,
            command: self.listFindingAggregations,
            inputKey: \ListFindingAggregationsRequest.nextToken,
            outputKey: \ListFindingAggregationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFindingAggregations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountIds: The Amazon Web Services account IDs to retrieve finding aggregation data for.
    ///   - aggregationRequest: Details of the aggregation request that is used to filter your aggregation results.
    ///   - aggregationType: The type of the aggregation request.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingAggregationsPaginator(
        accountIds: [StringFilter]? = nil,
        aggregationRequest: AggregationRequest? = nil,
        aggregationType: AggregationType,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFindingAggregationsRequest, ListFindingAggregationsResponse> {
        let input = ListFindingAggregationsRequest(
            accountIds: accountIds, 
            aggregationRequest: aggregationRequest, 
            aggregationType: aggregationType, 
            maxResults: maxResults
        )
        return self.listFindingAggregationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFindings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingsPaginator(
        _ input: ListFindingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFindingsRequest, ListFindingsResponse> {
        return .init(
            input: input,
            command: self.listFindings,
            inputKey: \ListFindingsRequest.nextToken,
            outputKey: \ListFindingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFindings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: Details on the filters to apply to your finding results.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - sortCriteria: Details on the sort criteria to apply to your finding results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingsPaginator(
        filterCriteria: FilterCriteria? = nil,
        maxResults: Int? = nil,
        sortCriteria: SortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFindingsRequest, ListFindingsResponse> {
        let input = ListFindingsRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            sortCriteria: sortCriteria
        )
        return self.listFindingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMembers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMembersPaginator(
        _ input: ListMembersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMembersRequest, ListMembersResponse> {
        return .init(
            input: input,
            command: self.listMembers,
            inputKey: \ListMembersRequest.nextToken,
            outputKey: \ListMembersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMembers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - onlyAssociated: Specifies whether to list only currently associated members if True or to list all members within the organization if False.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMembersPaginator(
        maxResults: Int? = nil,
        onlyAssociated: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMembersRequest, ListMembersResponse> {
        let input = ListMembersRequest(
            maxResults: maxResults, 
            onlyAssociated: onlyAssociated
        )
        return self.listMembersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUsageTotals(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsageTotalsPaginator(
        _ input: ListUsageTotalsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUsageTotalsRequest, ListUsageTotalsResponse> {
        return .init(
            input: input,
            command: self.listUsageTotals,
            inputKey: \ListUsageTotalsRequest.nextToken,
            outputKey: \ListUsageTotalsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUsageTotals(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountIds: The Amazon Web Services account IDs to retrieve usage totals for.
    ///   - maxResults: The maximum number of results the response can return. If your request would return more than the maximum the response will return a nextToken value, use this value when you call the action again to get the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsageTotalsPaginator(
        accountIds: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUsageTotalsRequest, ListUsageTotalsResponse> {
        let input = ListUsageTotalsRequest(
            accountIds: accountIds, 
            maxResults: maxResults
        )
        return self.listUsageTotalsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchVulnerabilities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchVulnerabilitiesPaginator(
        _ input: SearchVulnerabilitiesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchVulnerabilitiesRequest, SearchVulnerabilitiesResponse> {
        return .init(
            input: input,
            command: self.searchVulnerabilities,
            inputKey: \SearchVulnerabilitiesRequest.nextToken,
            outputKey: \SearchVulnerabilitiesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchVulnerabilities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: The criteria used to filter the results of a vulnerability search.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchVulnerabilitiesPaginator(
        filterCriteria: SearchVulnerabilitiesFilterCriteria,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchVulnerabilitiesRequest, SearchVulnerabilitiesResponse> {
        let input = SearchVulnerabilitiesRequest(
            filterCriteria: filterCriteria
        )
        return self.searchVulnerabilitiesPaginator(input, logger: logger)
    }
}

extension Inspector2.GetCisScanResultDetailsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.GetCisScanResultDetailsRequest {
        return .init(
            accountId: self.accountId,
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            scanArn: self.scanArn,
            sortBy: self.sortBy,
            sortOrder: self.sortOrder,
            targetResourceId: self.targetResourceId
        )
    }
}

extension Inspector2.GetClustersForImageRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.GetClustersForImageRequest {
        return .init(
            filter: self.filter,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Inspector2.ListAccountPermissionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListAccountPermissionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            service: self.service
        )
    }
}

extension Inspector2.ListCisScanConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListCisScanConfigurationsRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortBy: self.sortBy,
            sortOrder: self.sortOrder
        )
    }
}

extension Inspector2.ListCisScanResultsAggregatedByChecksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListCisScanResultsAggregatedByChecksRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            scanArn: self.scanArn,
            sortBy: self.sortBy,
            sortOrder: self.sortOrder
        )
    }
}

extension Inspector2.ListCisScanResultsAggregatedByTargetResourceRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListCisScanResultsAggregatedByTargetResourceRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            scanArn: self.scanArn,
            sortBy: self.sortBy,
            sortOrder: self.sortOrder
        )
    }
}

extension Inspector2.ListCisScansRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListCisScansRequest {
        return .init(
            detailLevel: self.detailLevel,
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortBy: self.sortBy,
            sortOrder: self.sortOrder
        )
    }
}

extension Inspector2.ListCoverageRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListCoverageRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Inspector2.ListCoverageStatisticsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListCoverageStatisticsRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            groupBy: self.groupBy,
            nextToken: token
        )
    }
}

extension Inspector2.ListDelegatedAdminAccountsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListDelegatedAdminAccountsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Inspector2.ListFiltersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListFiltersRequest {
        return .init(
            action: self.action,
            arns: self.arns,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Inspector2.ListFindingAggregationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListFindingAggregationsRequest {
        return .init(
            accountIds: self.accountIds,
            aggregationRequest: self.aggregationRequest,
            aggregationType: self.aggregationType,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Inspector2.ListFindingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListFindingsRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortCriteria: self.sortCriteria
        )
    }
}

extension Inspector2.ListMembersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListMembersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            onlyAssociated: self.onlyAssociated
        )
    }
}

extension Inspector2.ListUsageTotalsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.ListUsageTotalsRequest {
        return .init(
            accountIds: self.accountIds,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Inspector2.SearchVulnerabilitiesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Inspector2.SearchVulnerabilitiesRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            nextToken: token
        )
    }
}
